package com.zdy.service;

import android.app.Service;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.text.TextUtils;
import android.util.Log;

import com.example.networklibrary.SharedPreferencesUtils;
import com.example.networklibrary.config.KeyInterface;
import com.example.networklibrary.model.RFID;
import com.phychips.rcp.RcpApi2;
import com.phychips.rcp.iRcpEvent2;
import com.zdy.showgoods.ActivityLogin;

import org.greenrobot.eventbus.EventBus;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


/**
 * RFID识别服务
 */
public class RFIDReadService extends Service {

    // 通过binder实现调用者client与Service之间的通信
    private MyBinder mBinder = new MyBinder();

    public class MyBinder extends Binder {
        public RFIDReadService getService() {
            return RFIDReadService.this;
        }
    }

    public RFIDReadService() {
    }

    private RcpApi2 rcpApi2Instance;
    private iRcpEvent2 rCpListener = new iRcpEvent2() {
        @Override
        public void onResetReceived() {
            Log.e("服务", "onResetReceived");
        }

        @Override
        public void onSuccessReceived(int[] data, int commandCode) {
            Log.e("服务", "onSuccessReceived-data=" + Arrays.toString(data) + "，commandCode=" + commandCode);
        }

        @Override
        public void onFailureReceived(int[] errCode) {
            Log.e("服务", "onFailureReceived-errCode=" + Arrays.toString(errCode));
        }

        @Override
        public void onTagWithTidReceived(int[] pcEpc, int[] tid) {
            Log.e("服务", "onTagWithTidReceived-pcEpc=" + Arrays.toString(pcEpc) + "，tid=" + Arrays.toString(tid));
        }

        @Override
        public void onTagWithRssiReceived(int[] pcEpc, int rssi) {
            Log.e("服务", "onTagWithRssiReceived-pcEpc=" + Arrays.toString(pcEpc) + "，rssi=" + rssi);
        }

        @Override
        public void onReaderInfoReceived(int[] data) {
            Log.e("服务", "onReaderInfoReceived-data=" + Arrays.toString(data));
        }

        @Override
        public void onRegionReceived(int region) {
            // TODO 设置区域的返回
            // 0x11 - Korea - 17
            // 0x22 - US - 34
            // 0x31 - EU - 49
            // 0x41 - Japan - 65
            // 0x52 - China - 82
            Log.e("服务", "onRegionReceived-region=" + region);
        }

        @Override
        public void onSelectParamReceived(int[] selParam) {
            Log.e("服务", "onSelectParamReceived-selParam=" + Arrays.toString(selParam));
        }

        @Override
        public void onQueryParamReceived(int[] data) {
            Log.e("服务", "onQueryParamReceived-data=" + Arrays.toString(data));
        }

        @Override
        public void onChannelReceived(int channel, int channelOffset) {
            // TODO 设置通道的返回
            Log.e("服务", "onChannelReceived-channel=" + channel + "，channelOffset=" + channelOffset);
        }

        @Override
        public void onFhLbtReceived(int[] data) {
            Log.e("服务", "onFhLbtReceived-data=" + Arrays.toString(data));
        }

        @Override
        public void onTxPowerLevelReceived(int data) {
            // TODO 设置输出功率（识别读取距离）
            Log.e("服务", "onTxPowerLevelReceived-data=" + data);
        }

        @Override
        public void onTagMemoryReceived(int[] data) {
            Log.e("服务", "onTagMemoryReceived-data=" + Arrays.toString(data));
        }

        @Override
        public void onTagMemoryLongReceived(int[] dest) {
            Log.e("服务", "onTagMemoryLongReceived-dest=" + Arrays.toString(dest));
        }

        @Override
        public void onBatteryStateReceived(int[] dest) {
            Log.e("服务", "onBatteryStateReceived-dest=" + Arrays.toString(dest));
        }

        @Override
        public void onSessionReceived(int session) {
            Log.e("服务", "onSessionReceived-session=" + session);
        }

        @Override
        public void onTagReceived(int[] pcEpc) {
            Log.e("服务", "onTagReceived-pc+Epc:" + Arrays.toString(pcEpc));  // onTagReceived-pcEpc:[32, 0, 0, 0, 48, 0, 120, 0, 7, 64]
            // 获取处理过的EPC
            String newEpc = getEPC(pcEpc);
            RFID rfid = new RFID();
            rfid.setCode(newEpc);
            EventBus.getDefault().post(rfid);

            // TODO 因为现在没有商品标签和员工标签的标记，所以只能把都当成商品标签先识别商品，商品识别失败再去识别员工
            // 商品识别展示处理,员工识别处理现在在商品处理里面
            // TODO 多次识别导致多次请求的处理，必须要处理，不然太消耗内存了

            // 识别商品处理，一个，多个
            if (jewelsEPCList == null)
                jewelsEPCList = new ArrayList<>();

            boolean contains = jewelsEPCList.contains(newEpc);
            Log.e("服务", "集合中是否存在：" + contains);
//            if (!contains && !isRequest) {
//                getCommodity(newEpc);
//            }

        }
    };

    private List<String> jewelsEPCList;
    private boolean isRequest = false;

    private String getEPC(int[] pcEpc) {
        // 先把第一位,第二位的pc码去掉，得到EPC码
        int[] epc = new int[pcEpc.length - 2];
        for (int x = 2; x < pcEpc.length; x++) {
            epc[x - 2] = pcEpc[x];
        }
        Log.e("服务", "onTagReceived-Epc:" + Arrays.toString(epc));

        return getEPCClearZero(epc);
//        return getEPCWithZero(epc);
    }

    /**
     * EPC去掉前面补的0的，例如：300078000721
     *
     * @param epc
     * @return
     */
    private String getEPCClearZero(int[] epc) {
        StringBuffer sb1 = new StringBuffer();
        boolean isAdd = false;
        boolean isFirstAdd = true;
        for (int y = 0; y < epc.length; y++) {
            if (epc[y] < 0) {
                epc[y] = 256 + epc[y];
            }

            if (epc[y] == 0) {
                if (isAdd) {
                    if (Integer.toHexString(epc[y]).length() == 1) {
                        sb1.append("0" + Integer.toHexString(epc[y]));
                    } else {
                        sb1.append(Integer.toHexString(epc[y]));
                    }
                }

            } else {
                if (Integer.toHexString(epc[y]).length() == 1 && !isFirstAdd) {
                    sb1.append("0" + Integer.toHexString(epc[y]));
                } else {
                    isFirstAdd = false;
                    sb1.append(Integer.toHexString(epc[y]));
                }
                isAdd = true;
            }
        }
        Log.e("服务", "getEPCClearZero：" + sb1.toString());
        return sb1.toString();
    }

    /**
     * EPC没有去掉前面补0的，标签中的EPC是什么就读取是什么，例如：0000300078000721
     *
     * @param epc
     * @return
     */
    private String getEPCWithZero(int[] epc) {
        StringBuffer sb = new StringBuffer();
        for (int y = 0; y < epc.length; y++) {
            if (epc[y] < 0) {
                epc[y] = 256 + epc[y];
            }

            if (Integer.toHexString(epc[y]).length() == 1) {
                sb.append("0" + Integer.toHexString(epc[y]));
            } else {
                sb.append(Integer.toHexString(epc[y]));
            }
        }
        Log.e("服务", "getEPCWithZero：" + sb.toString());
        return sb.toString();
    }

    /**
     * 清除jewelsEPCList数据
     */
    public void clearJewelsEPCList() {
        jewelsEPCList.clear();
        Log.e("服务", "清除jewelsEPCList数据：" + jewelsEPCList.size());
    }

    Handler handler = new Handler();
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            boolean b = rcpApi2Instance.startReadTags(0, 0, 0);
            Log.e("服务", "重新开启RFID读取器：" + b);
        }
    };

    /**
     * 停止读写RFID标签
     */
    public void stopReadRFID() {
        boolean b = rcpApi2Instance.stopReadTags();
        Log.e("服务", "关闭RFID读取器：" + b);

        if (b) {
            handler.postDelayed(runnable, 1500);
        }
    }

    /**
     * 停止读写RFID标签并关闭设备
     */
    public void stopCloseAndStopReadRFID() {
        boolean b = rcpApi2Instance.stopReadTags();
        Log.e("服务", "停止RFID读取器：" + b);
        if (b) {
            boolean close = rcpApi2Instance.close();
            Log.e("服务", "关闭RFID读取器：" + b + ",关闭设备:" + close);
        }
    }

    private SharedPreferences SP_USER_INFO;

    @Override
    public void onCreate() {
        super.onCreate();
        //SP_USER_INFO = App.getContext().getSharedPreferences(AppDelegate.SP_USER_INFO, MODE_PRIVATE);

        Log.d("服务", "CCCCCC");
        if (rcpApi2Instance == null) {
            rcpApi2Instance = RcpApi2.getInstance();
            rcpApi2Instance.setOnRcpEventListener(rCpListener);
            // 打开RFID识别器,开启标签读取
            boolean open = rcpApi2Instance.open();
            boolean b = rcpApi2Instance.startReadTags(0, 0, 0);
            Log.e("服务", "RFIDReadService-onCreate-open=" + open + ",startReadTags=" + b);
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.e("服务", "RFIDReadService-onBind");
        return mBinder;
    }

    // 每次client在调用了unbindService方法之后，该client会与Service解除绑定，在与某个client解除绑定之后，
    // Service会检测是否还有其他的client与其连接绑定，如果没有其他任何client与其处于连接状态，那么Service会执行onUnbind方法，
    // 然后执行onDestroy方法，最终销毁自己
    @Override
    public boolean onUnbind(Intent intent) {
        Log.e("服务", "RFIDReadService-onUnbind-解绑服务-RFIDReadService");
        return super.onUnbind(intent);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e("服务", "RFIDReadService-onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        Log.e("服务", "RFIDReadService-onDestroy");
        super.onDestroy();
    }

    /**
     * 判断某个界面是否在前台
     *
     * @param className 界面的类名
     * @return 是否在前台显示
     */
//    public static boolean isForeground(String className) {
//        if (TextUtils.isEmpty(className))
//            return false;
//        ActivityManager am = (ActivityManager) App.getContext().getSystemService(Context.ACTIVITY_SERVICE);
//        List<ActivityManager.RunningTaskInfo> list = am.getRunningTasks(1);
//        if (list != null && list.size() > 0) {
//            ComponentName cpn = list.get(0).topActivity;
//            if (className.equals(cpn.getClassName()))
//                return true;
//        }
//        return false;
//    }
//
//    /**
//     * 切换员工
//     *
//     * @param epc 员工编码，应该跟网站上的code一模一样
//     */
//    private void exchangeEmployee(final String epc) {
//        // 若是当前识别到的code就是当前登录员工，那就不再请求
//        if (!epc.equals(SP_USER_INFO.getString(AppDelegate.CurrentEmployeeCode, ""))) {
//            if (!NetWorkUtils.isConnectedByState(App.getContext())) {
//                isRequest = false;
//                ToastUtil.showToast(App.getContext(), App.getContext().getString(R.string.ERROR_Toast_NO_NETWORK));
//            } else {
//                // 获取员工信息
//                String url_get_employee = MyApi.getBaseUrl() + MyApi.API_EMPLOYEE_LIST;
//                Log.d(AppDelegate.LOGGER_TAG, "\n查询员工信息-URL:" + url_get_employee);
//                String appKey = SP_USER_INFO.getString(AppDelegate.AppKey, "");
//                Log.d(AppDelegate.LOGGER_TAG, "\nAPP_KEYS:" + appKey);
//
//                // {"clientIp":"124.160.111.194","errorCode":"PERMISSION_DENIED","httpStatus":401,"message":"请先登陆！"}
//                OkGo.<String>post(url_get_employee).tag(this)
//                        // authorization:APP_KEYS c1555705 -29f 8 - 400 a - 8959 - f525ef24a3a8
//                        .headers("authorization", "APP_KEYS " + appKey)
//                        .upJson("{\"code\":\"" + epc + "\"}")
//                        .execute(new MyStringCallBack() {
//                            @Override
//                            public void onSuccess(String s, Call call, Response response) {
//                                Logger.d("查询员工信息请求结果：" + s);
//                                EmployeeList employeeList = JSON.parseObject(s, EmployeeList.class);
//                                List<EmployeeList.DataBean> employees = employeeList.getData();
//                                if (employees.size() != 0) {
//                                    EmployeeList.DataBean employee = employees.get(0);
//                                    Logger.json(JSON.toJSONString(employee));
//                                    // 如果是识别的就是当前登录的员工不做处理
//                                    // 保存当前的员工卡Epc code,目前用的就是员工编码，保存员工信息（名字和职位）
//                                    SP_USER_INFO.edit().putString(AppDelegate.CurrentEmployeeCode, epc).apply();
//                                    SP_USER_INFO.edit().putString(AppDelegate.Name, employee.getName()).apply();
//                                    SP_USER_INFO.edit().putString(AppDelegate.CurrentUser, employee.getUsername()).apply(); // 切换之后保存当前登录的账号
//                                    SP_USER_INFO.edit().putString(AppDelegate.Position, employee.getPositionName()).apply();
//                                    LocalBroadcastManager.getInstance(App.getContext()).sendBroadcast(
//                                            new Intent(AppDelegate.ACTION_UPDATE_EMPLOYEE_DATA));
//                                }
//
//                                isRequest = false;
//                            }
//
//                            @Override
//                            public void MyOnError(Call call, Response response, Exception e, String errorMsg) {
//                                Logger.e("查询员工信息请求错误:" + errorMsg);
//                                if (errorMsg != null) {
//                                    Error error = JSON.parseObject(errorMsg, Error.class);
//                                    // 登录过期处理 {"clientIp":"124.160.111.194","errorCode":"PERMISSION_DENIED","httpStatus":401,"message":"请先登陆！"}
//                                    if ("PERMISSION_DENIED".equals(error.getErrorCode()) && "请先登陆！".equals(error.getMessage())) {
//                                        reLogin();
//                                    } else {
//                                        isRequest = false;
//                                        ToastUtil.showToast(App.getContext(), error.getMessage());
//                                    }
//                                } else {
//                                    isRequest = false;
//                                    ToastUtil.showToast(App.getContext(), "员工信息查询失败");
//                                }
//                            }
//                        });
//            }
//        } else {
//            isRequest = false;
//        }
//    }
//
//    /**
//     * 获取商品信息
//     *
//     * @param epc
//     */
//    private void getCommodity(final String epc) {
//        if (!NetWorkUtils.isConnectedByState(App.getContext())) {
//            isRequest = false;
//            ToastUtil.showToast(App.getContext(), App.getContext().getString(R.string.ERROR_Toast_NO_NETWORK));
//        } else {
//            isRequest = true;
//
//            String url_get_commodity = MyApi.getBaseUrl() + MyApi.API_SKU_INFO_LIST;
//            Log.d(AppDelegate.LOGGER_TAG, "\n查询商品信息-URL:" + url_get_commodity);
//            String appKey = SP_USER_INFO.getString(AppDelegate.AppKey, "");
//            Log.d(AppDelegate.LOGGER_TAG, "\nAPP_KEYS:" + appKey);
//
//            OkGo.<String>post(url_get_commodity).tag(this)
//                    // authorization:APP_KEYS c1555705 -29f 8 - 400 a - 8959 - f525ef24a3a8
//                    .headers("authorization", "APP_KEYS " + appKey)
//                    .upJson("{\"tags\":[" + epc + "]}")
//                    .execute(new MyStringCallBack() {
//                        @Override
//                        public void onSuccess(String s, Call call, Response response) {
//                            Logger.d("查询商品信息请求结果：" + s);
//                            CommodityList commodityList = JSON.parseObject(s, CommodityList.class);
//                            List<CommodityList.DataBean> data = commodityList.getData();
//                            if (data.size() != 0) {
//                                // 获取到查询到的商品
//                                CommodityList.DataBean commodity = data.get(0);
//                                Logger.json(JSON.toJSONString(commodity));
//                                // TODO 获取到商品之后的展示和处理
//                                getCommodityDetail(commodity, epc);
//                            } else {
//                                // TODO 不是商品可能就是员工,暂时这么处理
//                                // 员工识别切换处理
//                                exchangeEmployee(epc);
//                            }
//                        }
//
//                        @Override
//                        public void MyOnError(Call call, Response response, Exception e, String errorMsg) {
//                            Logger.e("查询商品信息请求错误:" + errorMsg);
//                            if (errorMsg != null) {
//                                Error error = JSON.parseObject(errorMsg, Error.class);
//                                // 登录过期处理 {"clientIp":"124.160.111.194","errorCode":"PERMISSION_DENIED","httpStatus":401,"message":"请先登陆！"}
//                                if ("PERMISSION_DENIED".equals(error.getErrorCode()) && "请先登陆！".equals(error.getMessage())) {
//                                    reLogin();
//                                } else {
//                                    isRequest = false;
//                                    ToastUtil.showToast(App.getContext(), error.getMessage());
//                                }
//                            } else {
//                                isRequest = false;
//                                ToastUtil.showToast(App.getContext(), "商品信息查询失败");
//                            }
//                        }
//                    });
//        }
//    }
//
//    /**
//     * 获取商品详细信息
//     *
//     * @param commodity
//     */
//    private void getCommodityDetail(final CommodityList.DataBean commodity, final String epc) {
//        if (!NetWorkUtils.isConnectedByState(App.getContext())) {
//            isRequest = false;
//            ToastUtil.showToast(App.getContext(), App.getContext().getString(R.string.ERROR_Toast_NO_NETWORK));
//        } else {
//            String url_get_commodity_detail = MyApi.getBaseUrl() + MyApi.API_PRODUCT_DETAIL + commodity.getProductId();
//            Log.d(AppDelegate.LOGGER_TAG, "\n查询商品详细信息-URL:" + url_get_commodity_detail);
//            String appKey = SP_USER_INFO.getString(AppDelegate.AppKey, "");
//            Log.d(AppDelegate.LOGGER_TAG, "\nAPP_KEYS:" + appKey);
//
//            OkGo.<String>post(url_get_commodity_detail).tag(this)
//                    // authorization:APP_KEYS c1555705 -29f 8 - 400 a - 8959 - f525ef24a3a8
//                    .headers("authorization", "APP_KEYS " + appKey)
//                    .upJson("")
//                    .execute(new MyStringCallBack() {
//                        @Override
//                        public void onSuccess(String s, Call call, Response response) {
//                            Logger.d("查询商品详细信息请求结果：" + s);
//                            CommodityDetails commodityDetails = JSON.parseObject(s, CommodityDetails.class);
//                            Logger.json(JSON.toJSONString(commodityDetails));
//                            // 若已经查询到了，那么就添加到正在展示的集合里面
//                            boolean add = jewelsEPCList.add(epc);
//                            Log.e("服务", "添加是否成功：" + add + "，jewelsEPCList.size:" + jewelsEPCList.size());
//
//                            // 重新封装需要展示的数据
//                            ShowJewels showJewels = new ShowJewels();
//                            showJewels.setSkuName(commodity.getProductName());
//                            showJewels.setSkuId(commodity.getBarcode()); // TODO 暂时用 barCode(商品条码) 作为 sku
//                            showJewels.setImageUrl(commodity.getImageUrl());
//                            showJewels.setImagePath(commodity.getImagePath());
//                            showJewels.setImageThumbnailUrl(commodity.getImageThumbnailUrl());
//                            showJewels.setImageThumbnailPath(commodity.getImageThumbnailPath());
//
//                            showJewels.setCustomFieldValue01(commodityDetails.getCustomFieldValue01());
//                            showJewels.setCustomFieldValue02(commodityDetails.getCustomFieldValue02());
//                            showJewels.setCustomFieldValue03(commodityDetails.getCustomFieldValue03());
//                            showJewels.setCustomFieldValue04(commodityDetails.getCustomFieldValue04());
//                            showJewels.setCustomFieldValue05(commodityDetails.getCustomFieldValue05());
//                            showJewels.setCustomFieldValue06(commodityDetails.getCustomFieldValue06());
//                            showJewels.setCustomFieldValue07(commodityDetails.getCustomFieldValue07());
//                            showJewels.setCustomFieldValue08(commodityDetails.getCustomFieldValue08());
//                            showJewels.setCustomFieldValue09(commodityDetails.getCustomFieldValue09());
//                            showJewels.setCustomFieldValue10(commodityDetails.getCustomFieldValue10());
//                            showJewels.setCustomFieldValue11(commodityDetails.getCustomFieldValue11());
//                            showJewels.setCustomFieldValue12(commodityDetails.getCustomFieldValue12());
//                            showJewels.setCustomFieldValue13(commodityDetails.getCustomFieldValue13());
//
//                            // 若是商品界面没有打开，就打开商品界面
//                            if (!isForeground("com.century.jewelpr9200.activity.ShowJewelActivity")) {
//                                Log.e("发送重新封装后的珠宝数据-新建展示", showJewels.toString());
//                                Intent intent = new Intent(App.getContext(), ShowJewelActivity.class);
//                                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//                                intent.putExtra(AppDelegate.ShowJewels, showJewels);
//                                startActivity(intent);
//                            } else {
//                                // 更新珠宝数据
//                                Log.e("发送重新封装后的珠宝数据-更新展示", showJewels.toString());
//                                Intent intent = new Intent(AppDelegate.ACTION_ADD_JEWEL);
//                                intent.putExtra(AppDelegate.ShowJewels, showJewels);
//                                LocalBroadcastManager.getInstance(App.getContext()).sendBroadcast(intent);
//                            }
//
//                            isRequest = false;
//
//                        }
//
//                        @Override
//                        public void MyOnError(Call call, Response response, Exception e, String errorMsg) {
//                            Logger.e("查询商品详细信息请求错误:" + errorMsg);
//                            if (errorMsg != null) {
//                                Error error = JSON.parseObject(errorMsg, Error.class);
//                                // 登录过期处理 {"clientIp":"124.160.111.194","errorCode":"PERMISSION_DENIED","httpStatus":401,"message":"请先登陆！"}
//                                if ("PERMISSION_DENIED".equals(error.getErrorCode()) && "请先登陆！".equals(error.getMessage())) {
//                                    reLogin();
//                                } else {
//                                    isRequest = false;
//                                    ToastUtil.showToast(App.getContext(), error.getMessage());
//                                }
//                            } else {
//                                isRequest = false;
//                                ToastUtil.showToast(App.getContext(), "商品详情信息查询失败");
//                            }
//
//                        }
//                    });
//
//        }
//
//    }
//
//    public void reLogin() {
//        if (!NetWorkUtils.isConnectedByState(App.getContext())) {
//            isRequest = false;
//            ToastUtil.showToast(App.getContext(), App.getContext().getString(R.string.ERROR_Toast_NO_NETWORK));
//        } else {
//            // ToastUtil.showToast(App.getContext(), "账号过期，正准备重新登录...");
//
//            final SharedPreferences spUserInfo = getSharedPreferences(AppDelegate.SP_USER_INFO, MODE_PRIVATE);
//            String url_login = spUserInfo.getString(AppDelegate.ServerAddress, "") + MyApi.API_LOGIN;
//            Log.d(AppDelegate.LOGGER_TAG, "\n重新登录-URL:" + url_login);
//
//            LoginRequest loginRequest = new LoginRequest();
//            loginRequest.setBusinessModuleCode("HDW");
//            loginRequest.setWarehouseCode("");
//            loginRequest.setAccountType("EMPLOYEE");
//            loginRequest.setUsername(spUserInfo.getString(AppDelegate.UserName, ""));
//            loginRequest.setPassword(spUserInfo.getString(AppDelegate.Password, ""));
//            String loginRequestString = JSON.toJSONString(loginRequest);
//            Log.d(AppDelegate.LOGGER_TAG, "\n重新登录-参数:" + loginRequestString);
//
//            OkGo.<String>post(url_login).tag(this)
//                    .upJson(loginRequestString)
//                    .execute(new MyStringCallBack() {
//                        @Override
//                        public void onSuccess(String s, Call call, okhttp3.Response response) {
//                            Logger.d("重新登录请求结果-AppKey=" + s);
//                            String[] split = s.split("\"");
//                            // 重新保存AppKey
//                            spUserInfo.edit().putString(AppDelegate.AppKey, split[1]).apply();
//                            // ToastUtil.showToast(App.getContext(), "自动重新登录成功！");
//                            isRequest = false;
//                        }
//
//                        @Override
//                        public void MyOnError(Call call, okhttp3.Response response, Exception e, String errorMsg) {
//                            Logger.e("重新登录请求错误:" + errorMsg);
//                            isRequest = false;
//                            // 重新登录失败，不管什么错误都需要进入登录界面，重新登录
//                            // TODO 重新登录失败,假如是登录密码改了,进入Login界面应该要把之前打开的Activity全部关闭， 想想咋搞，
//                            // TODO 而且获取员工，和获取商品 重新登录失败的时候，这块的处理应该有一点点不同
//                            ToastUtil.showToast(App.getContext(), "自动重新登录失败！即将进入登录界面...");
//                            Intent intent = new Intent(App.getContext(), LoginActivity.class);
//                            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//                            startActivity(intent);
//                        }
//                    });
//        }
//    }

}
